Pytorch中Torch 工具包的数学操作汇总速查
torch package 包含了多维张量的数据结构, 以及基于其上的多种数学操作. 此外,它还提供了许多用于高效序列化 Tensor 和任意类型的实用工具包, 以及一起其它有用的实用工具包.
变量 | 解释 |
|—-|—-|
Tensors (张量) |
torch.istensor(obj) | 如果 obj 是一个 pytorch tensor, 则返回True.
torch.is_storage(obj) | 如果 obj 是一个 pytorch storage object, 则返回True
torch.set_default_tensor_type(t) | 设置默认类型
torch.numel(input) → int | 返回 input Tensor 中的元素总数
torch.set_printoptions(precision=None, threshold=None,edgeitems=None,linewidth=None, profile=None) | 设置打印选项. 从 Numpy 中采集数据
torch.set_flush_denormal(mode) | 为了防止一些不正常的元素产生，比如特别小的数，pytorch支持如下设置
Creation Ops (创建操作) | |
torch.from_numpy(ndarray) → Tensor | 从 numpy.ndarray 类 创建一个 Tensor 类
torch.as_tensor(data, dtype=None, device=None) | |
torch.eye(n, m=None, out=None) | 返回对角线位置全为1, 其它位置全为0的二维 tensor
torch.zeros(sizes, out=None) → Tensor | 返回填充了标量值为 0 的 Tensor, 其形状由可变参量 sizes 定义
torch.zeros_like(input, out=None) → Tensor | 返回一个用标量值 0 填充的 Tensor, 其大小与 input 相同.
torch.ones(sizes, out=None) → Tensor | 返回填充了标量值 1 的 Tensor, 其形状由可变参数 sizes 定义
torch.ones_like(input, out=None) → Tensor | 返回一个用标量值 1 填充的张量, 大小与 input 相同
torch.empty() |
torch.empty_like() |
torch.full(size, fill_value, …) | 返回大小为sizes,单位值为fill_value的矩阵
torch.full_like(input, fill_value, …) | 返回与input相同size，单位值为fill_value的矩阵
torch.linspace(start, end, steps=100, out=None) → Tensor | 返回 start 和 end 之间等间隔 steps 点的一维 Tensor.输出 是尺寸 steps 为一维 tensor
torch.logspace(start, end, steps=100, out=None) → Tensor | 返回一个在 10^start 和 10^end之间的对数间隔 steps 点的一维 Tensor，输出是长度为 steps 的一维 tensor
torch.arange(start=0, end, step=1, out=None) → Tensor | 从 start 用步长为 step 开始, 间隔在 [start, end) 中的值返回大小层次为 floor((end−start)/step)floor((end−start)/step) 的一维 Tensor.
torch.range(start, end, step=1, out=None) → Tensor | 返回一个在 start 到 end 并且步长为 step 的区间内, 大小为 floor((end−start)/step)+1floor((end−start)/step)+1 为一维 Tensor.
Indexing, Slicing, Joining, Mutating Ops (索引, 切片, 连接, 换位) 操作 |
torch.cat(seq, dim=0, out=None) → Tensor | 在给定维度上对输入的张量序列 seq 进行连接操作. 所有张量必须具有相同的形状(在 cat 维度中除外) 或为空.
torch.chunk(tensor, chunks, dim=0) | 在给定维度(轴)上将输入张量进行分块处理.
torch.gather(input, dim, index, out=None) → Tensor | 沿给定轴 dim ,将输入索引张量 index 指定位置的值进行聚合.
torch.index_select(input, dim, index, out=None) → Tensor | 沿着指定维度 dim 对输入进行切片,取 index 中指定的相应项 ( index 为一个 LongTensor ),然后返回到一个新的张量.返回的张量与原始张量 Tensor 有相同的维度(在指定轴上)
torch.masked_select(input, mask, out=None) → Tensor | 根据掩码张量 mask 中的二元值,取输入张量中的指定项 ( mask 为一个 ByteTensor ),将取值返回到一个新的一维张量.张量 mask 与 input 的shape 或维度不需要相同,但是他们必须是 broadcastable .
torch.nonzero(input, out=None) → LongTensor | 返回一个包含输入 input 中非零元素索引的张量. 输出张量中的每行包含 input 中非零元素的索引.如果输入张量 input 有 n 维,则输出的索引张量 out 的 size 为 z x n , 这里 z 是输入张量 input 中所有非零元素的个数.
torch.where(condition, x, y) | 按照条件从x和y中选出满足条件的元素组成新的tensor。
torch.split(tensor, split_size, dim=0) | 将输入张量分割成相等 size 的 chunks (如果可分).如果沿指定维的张量形状大小不能被 split_size 整分, 则最后一个分块会小于其它分块
torch.squeeze(input, dim=None, out=None) | 将 input 张量 size 中的 1 去除并返回.如果 input 的 shape 如 (Ax1xBxCx1xD)(Ax1xBxCx1xD) ,那么输出 shape 就为: (AxBxCxD)
torch.stack(sequence, dim=0, out=None) | 沿着一个新维度对输入张量序列进行连接.序列中所有的张量都应该为相同 size .
torch.reshape(input, shape) |
torch.view |
torch.t(input, out=None) → Tensor | 预期 input 为一个矩阵 (2 维张量), 并转置 0, 1 维.可以被视为函数 transpose(input, 0, 1) 的简写函数
torch.take(input, indices) → Tensor | 在给定的索引处返回一个新的 Tensor ,其元素为 input . 输入张量被看作是一维张量.结果与索引具有相同的 shape
torch.transpose(input, dim0, dim1, out=None) → Tensor | 返回输入矩阵 input 的转置.交换给定维度 dim0 和 dim1 .out 张量与 input 张量共享内存,所以改变其中一个会导致另外一个也被修改.
torch.unbind(tensor, dim=0) | 移除一个张量的维度
torch.unsqueeze(input, dim, out=None) | 返回在指定位置插入维度 size 为 1 的新张量.返回张量与输入张量共享内存,所以改变其中一个的内容会改变另一个.如果 dim 为负,则将会被转化 dim+input.dim()+1
Random sampling (随机采样) |
torch.manual_seed(seed) | 设置生成随机数的种子,并返回一个
torch.initial_seed() | 返回用于生成随机数字的初始种子 (python long)
torch.get_rng_state() | 以ByteTensor的形式返回随机数发生器的状态
torch.set_rng_state(new_state) | 设置随机数发生器的参数
torch.bernoulli(input, out=None) → Tensor | 从伯努利分布中抽取二进制随机数 (0 或 1)
torch.multinomial(input, num_samples, replacement=False, out=None)→ LongTensor| 返回一个张量, 其中每一行包含在 input 张量对应行中多项式分布取样的 num_samples 索引 |
torch.normal(means, std, out=None) | 返回一个随机数张量, 随机数从给定平均值和标准差的离散正态分布中抽取.
torch.normal(mean=0.0, std, out=None) | 功能与上面函数类似, 但所有被抽取的元素共享均值
torch.normal(means, std=1.0, out=None) | 功能与上面函数类似, 但所有被抽取的元素共享标准差
torch.rand(sizes, out=None) → Tensor | 在区间 [0,1)[0,1) 中,返回一个填充了均匀分布的随机数的张量.这个张量的形状由可变参数 sizes 来定义
torch.randn(sizes, out=None) → Tensor | 返回一个从正态分布中填充随机数的张量, 其均值为 0 , 方差为 1.这个张量的形状被可变参数 sizes 定义
torch.randperm(n, out=None) → LongTensor | 返回一个从 0 to n - 1 的整数的随机排列
torch.rand(sizes, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) | 生成[0，1）的随机数
torch.rand_like(input, dtype=None, layout=None, device=None,requires_grad=False) | 按照输入的tensor的尺寸生成
torch.randint(low=0, high, size, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) | 在一个范围内生成整型的随机
torch.randint_like(input, low=0, high, dtype=None, layout=torch.strided, device=None, requires_grad=False) | 不解释
torch.randn(sizes, out=None, dtype=None, layout=torch.strided, device=None, requires_grad=False) | 返回01正太分布
torch.randn_like(input, dtype=None, layout=None, device=None, requires_grad=False) | 不解释
torch.randperm(n, out=None, dtype=torch.int64, layout=torch.strided, device=None, requires_grad=False) | 返回0到输入n的之间整数随机排列不含n
In-place random sampling (直接随机采样) |
torch.Tensor.bernoulli() | torch.bernoulli()的 in-place 版本
torch.Tensor.cauchy() | 从柯西分布中抽取数字
torch.Tensor.exponential() | 从指数分布中抽取数字
torch.Tensor.geometric() | 从几何分布中抽取元素
torch.Tensor.log_normal() | 对数正态分布中的样本
torch.Tensor.normal() | 是 torch.normal() 的 in-place 版本
torch.Tensor.random() | 离散均匀分布中采样的数字
torch.Tensor.uniform_() | 正态分布中采样的数字
Serialization (序列化) |
torch.save(obj, f, pickle_module=
torch.load(f, map_location=None, pickle_module=
Parallelism (并行化) |
torch.get_num_threads() → int | 获得 OpenMP 并行化操作的线程数目
torch.set_num_threads(int) | 设置 OpenMP 并行化操作的线程数目
Math operations (数学操作) |
Pointwise Ops (逐点操作) |
torch.abs(input, out=None) → Tensor | 计算给定 input 张量的元素的绝对值
torch.acos(input, out=None) → Tensor | 用 input 元素的反余弦返回一个新的张量
torch.add(input, value, out=None) | 将标量值 value 添加到输入张量 attr:input 的每个元素并返回一个新的结果张量
torch.add(input, value=1, other, out=None) | 张量 other 的每个元素乘以标量值 value 并加到张量 input 上, 返回生成的张量 out
torch.addcdiv(tensor, value=1, tensor1, tensor2, out=None) → Tensor | 将张量 tensor1 逐元素除以张量 tensor2, 然后乘以标量值 value 并加到张量 tensor 上.
torch.addcmul(tensor, value=1, tensor1, tensor2, out=None) → Tensor | 将张量 tensor1 逐元素与张量 tensor2 相乘, 然后乘以标量值 value 并加到张量 tensor 上.
torch.asin(input, out=None) → Tensor | 返回一个新的 Tensor , 其元素为张量 input 的每个元素的反正弦
torch.atan(input, out=None) → Tensor | 返回一个新的 Tensor , 其元素为张量 input 的每个元素的反正切
torch.atan2(input1, input2, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是输入张量 input1 和输入张量 input2 元素的反正切.
torch.ceil(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 的元素向上取整(取不小于每个元素的最小整数).
torch.clamp(input, min, max, out=None) → Tensor | 将输入张量 input 所有元素限制在区间 [min,max] 中并返回一个结果张量
torch.clamp(input, , min, out=None) → Tensor | 张量 input 的所有元素值大于或者等于 min
torch.clamp(input, , max, out=None) → Tensor | 张量 input 的所有元素值小于或者等于 max.
torch.cos(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 每个元素的余弦
torch.cosh(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 每个元素的双曲余弦
torch.div(input, value, out=None) | 将张量 input 的元素逐一除以标量值 value ,其结果作为一个新的张量返回.
torch.div(input, other, out=None) | 张量 input 的元素与张量 other 的元素逐一相除. 返回一个新的结果张量 out . 张量 input 与张量 other 的形状必须可 broadcastable.outi=inputi/otheri
torch.erf(tensor, out=None) → Tensor | 计算每个元素的误差函数
torch.erfinv(tensor, out=None) → Tensor | 计算每个元素的反向误差函数
torch.exp(tensor, out=None) → Tensor | 计算每个元素的指数
torch.floor(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 的元素向下取整(取不大于每个元素的最大整数).
torch.fmod(input, divisor, out=None) → Tensor | 计算除法余数.
torch.frac(tensor, out=None) → Tensor | 计算张量 tensor 每个元素的分数部分.
torch.lerp(start, end, weight, out=None) | 基于标量值 weight: , 在张量 start 与张量 end 之间做线性插值 并返回结果张量 out 。outi=starti+weight∗(endi−starti)
torch.log(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 所有元素的自然对数.
torch.log1p(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是(1 + input) 的自然对数.yi=log(xi+1)
torch.mul(input, value, out=None) | 将输入张量 input 的每个元素与标量值 value 相乘并返回一个新的结果张量.out=tensor∗value
torch.mul(input, other, out=None) | 张量 input 的元素与张量 other 的元素逐一相乘. 其结果作为一个新的张量返回.
torch.neg(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 的元素的负值.out=−1∗input
torch.pow(input, exponent, out=None) | 对输入张量 input 按元素求 exponent 次幂值并返回结果张量(其值作为结果张量的元素).
torch.pow(base, input, out=None) | base 是一个标量浮点值, input 是一个张量. 返回的张量 out 的形状与张量 input 的形状相同.
torch.reciprocal(input, out=None) → Tensor | 返回一个新的 Tensor , 其元素是张量 input 元素的倒数, i.e. 1.0/x
torch.remainder(input, divisor, out=None) → Tensor | 计算元素的除法的余数.
torch.round(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是输入张量的元素四舍五入到最近的整数
torch.rsqrt(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 元素的平方根的倒数.
torch.sigmoid(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 元素的sigmoid值
torch.sign(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 元素的符号.
torch.sin(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 元素的正弦.
torch.sinh(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 元素的双曲正弦
torch.sqrt(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 元素的平方根
torch.tan(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 元素的正切
torch.tanh(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 元素的双曲正切
torch.trunc(input, out=None) → Tensor | 返回一个新的张量 Tensor , 其元素是张量 input 元素的截断整数值 (直接去除小数部分) .
Reduction Ops (归约操作) |
torch.cumprod(input, dim, out=None) → Tensor | 返回元素 input 在给定维度 dim 下的累积积
torch.cumsum(input, dim, out=None) → Tensor | 返回元素 input 在给定维度 dim 下的累积和
torch.dist(input, other, p=2) → float | 返回(input - other)的p-范数 input 和 other 的形状必须满足 broadcastable.
torch.mean(input) → float | 返回张量 input 所有元素的均值.
torch.mean(input, dim, keepdim=False, out=None) → Tensor | 返回张量 input 在给定维度 dim 上每行的均值
torch.median(input) → float | 返回输出张量 input 所有元素的中位数.
torch.median(input, dim=-1, keepdim=False, values=None, indices=None) -> (Tensor, LongTensor) | 返回输出张量 input 在给定维度 dim 下每行的中位数. 同时返回一个包含中位数的索引 LongTensor.
torch.mode(input, dim=-1, keepdim=False, values=None, indices=None) -> | (Tensor, LongTensor) | 返回输入张量 input 在给定维数 dim 下每行元素的众数值. 同时也返回众数值的索引LongTensor.
torch.norm(input, p=2) → float | 返回输入张量 input 的p-范数
torch.norm(input, p, dim, keepdim=False, out=None) → Tensor | 返回输入张量 input 在给定维度 dim 下每行元素的p-范数.
torch.prod(input) → float | 返回输入张量 input 所有元素的乘积.
torch.prod(input, dim, keepdim=False, out=None) → Tensor | 返回输入张量 input 在给定维度 dim 下每行元素的积.
torch.unique(input, sorted=False, return_inverse=False) |以1D向量保存张量中不同的元素。剔除tensor中的重复元素，如果设置return_inverse=True，会得到一个元素在在原tensor中的映射表
torch.std(input, unbiased=True) → float | 返回输入张量 input 所有元素的标准差
torch.std(input, dim, keepdim=False, unbiased=True, out=None) → Tensor | 返回输入张量 input 在给定维度 dim 下每行元素的标准差
torch.sum(input) → float | 返回输入张量 input 所有元素的和
torch.sum(input, dim, keepdim=False, out=None) → Tensor | 返回输入张量 input 在给定维度 dim 下每行元素的和
torch.var(input, unbiased=True) → float | 返回输入张量 input 的方差.
torch.var(input, dim, keepdim=False, unbiased=True, out=None) → Tensor | 返回输入张量 input 在给定维度 dim 下每行的方差
Comparison Ops (比较操作) |
torch.eq(input, other, out=None) → Tensor | 比较元素是否相等
torch.equal(tensor1, tensor2) → bool | 如果两个张量有相同的形状和元素值, 则返回 True , 否则 False .
torch.ge(input, other, out=None) → Tensor | 逐元素比较 input 和 other , 即是否 input>=other .
torch.gt(input, other, out=None) → Tensor | 逐元素比较 input 和 other , 即是否 input>other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False
torch.kthvalue(input, k, dim=None, keepdim=False, out=None) -> (Tensor, | LongTensor) | 取输入张量 input 指定维上第 k 个最小值. 如果不指定 dim , 则默认为 input 的最后一维
torch.le(input, other, out=None) → Tensor | 逐元素比较 input 和 other , 即是否input<=other 如果两个张量有相同的形状和元素值, 则返回 True ,否则 False .
torch.lt(input, other, out=None) → Tensor | 逐元素比较 input 和other , 即是否 input
torch.max(input, other, out=None) → Tensor | 输入 input 每一个元素和对应的比较张量 other 进行比较, 留下较大的元素 max.
torch.min(input) → float | 返回输入张量 input 所有元素的最小值
torch.min(input, dim, keepdim=False, out=None) -> (Tensor, LongTensor) | 返回输入张量 input 在给定维度 dim 下每行元素的最小值. 其中第二个返回值是每个被找出的最小值的索引位置 ( argmin )
torch.min(input, other, out=None) → Tensor | 输入 input 每一个元素和对应的比较张量 other 进行比较, 留下较小的元素 min .
torch.ne(input, other, out=None) → Tensor | 逐元素比较 input 和 other , 即是否 tensor != other 如果两个张量有相同的形状和元素值, 则返回 True , 否则 False .
torch.sort(input, dim=None, descending=False, out=None) -> (Tensor, | LongTensor) | 对输入张量 input 沿着指定维按升序排序.
torch.topk(input, k, dim=None, largest=True, sorted=True, out=None) -> (Tensor, LongTensor) | 沿给定 dim 维度返回输入张量 input 中 k 个最大值. 如果不指定 dim , 则默认为 input的最后一维. 如果为 largest 为 False ,则返回最小的 k 个值. 返回一个元组 (values, indices) , 其中 indices是原始输入张量 input 中测元素下标. 如果设定布尔值 sorted 为 True , 将会确保返回的 k 个值被排序.
torch.isfinite(tensor) / torch.isinf(tensor) / torch.isnan(tensor) | 返回一个标记元素是否为 finite/inf/nan 的mask 张量。
Other Operations (其它操作) |
torch.bincount(self, weights=None, minlength=0) | 返回每个值得频数。
torch.cross(input, other, dim=-1, out=None) → Tensor | 返回沿着维度 dim 上, 两个张量 input 和 other 的向量积 (叉积), input 和 other 必须有相同的形状, 且指定的 dim 维上 size 必须为 3.
torch.diag(input, diagonal=0, out=None) → Tensor | 如果输入是一个向量( 1D 张量), 则返回一个以 input 为对角线元素的 2D 方阵.如果输入是一个矩阵( 2D 张量), 则返回一个包含 input 对角线元素的1D张量.
torch.flip(input, dims) | 按照给定维度翻转张量
torch.histc(input, bins=100, min=0, max=0, out=None) → Tensor | 计算输入张量的直方图
torch.meshgrid(seq) | 生成网格（可以生成坐标）。
torch.renorm(input, p, dim, maxnorm, out=None) → Tensor | 返回一个张量, 包含规范化后的各个子张量, 使得沿着 dim 维划分的各子张量的 p 范数小于 maxnorm
torch.trace(input) → float | 返回输入 2 维矩阵对角线元素的和(迹).
torch.tril(input, diagonal=0, out=None) → Tensor | 返回一个张量, 包含输入矩阵 ( 2D 张量)的下三角部分, 其余部分被设为 0.
torch.triu(input, diagonal=0, out=None) → Tensor | 返回一个张量, 包含输入矩阵 ( 2D 张量)的上三角部分, 其余部分被设为 0.
BLAS and LAPACK Operations (BLAS和LAPACK操作) |
torch.addbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor | 执行保存在 batch1 和 batch2 中的矩阵的批量点乘, 伴随着一个减少的相加步骤 (所有的矩阵乘法沿第一维累加). mat 被相加到最终的结果中.
torch.addmm(beta=1, mat, alpha=1, mat1, mat2, out=None) → Tensor | 执行矩阵 mat1 和 mat2 的相乘. 矩阵 mat 将与相乘的最终计算结果相加.
torch.addmv(beta=1, tensor, alpha=1, mat, vec, out=None) → Tensor | 执行矩阵 mat 和向量 vec 的相乘. 矩阵 tensor 将与相乘的最终计算结果相加.
torch.addr(beta=1, mat, alpha=1, vec1, vec2, out=None) → Tensor | 执行向量:attr:vec1 和 vec2 的外积, 并把外积计算结果与矩阵 mat相加
torch.baddbmm(beta=1, mat, alpha=1, batch1, batch2, out=None) → Tensor | 执行保存在 batch1 和 batch2 中的矩阵的批量点乘. mat 被相加到最终的结果中.
torch.bmm(batch1, batch2, out=None) → Tensor | 执行保存在 batch1 和 batch2 中的矩阵的批量点乘.
torch.btrifact(A, info=None, pivot=True) → Tensor, IntTensor | 批量 LU 分解.
torch.btrisolve(b, LU_data, LU_pivots) → Tensor | 批量 LU 解.返回线性系统 Ax = b 的 LU 解
torch.dot(tensor1, tensor2) → float | 计算两个张量的点乘 (内积).
torch.eig(a, eigenvectors=False, out=None) -> (Tensor, Tensor) | 计算实数方阵的特征值和特征向量.
torch.det(A) | 返回矩阵A的行列式
torch.gels(B, A, out=None) → Tensor | 计算秩为 mm 的， 大小为 m x n 的矩阵 AA 最小二乘和最小范数问题的解
torch.geqrf(input, out=None) -> (Tensor, Tensor) | 直接调用 LAPACK 的低层函数
torch.ger(vec1, vec2, out=None) → Tensor | 计算 vec1 和 vec2 的外积. 如果 vec1 是一个长度为n 的向量, vec2 是一个长度为 m 的向量, 那么 out 必须是一个 n x m 的矩阵
torch.gesv(B, A, out=None) -> (Tensor, Tensor) | X, LU = torch.gesv(B, A) ,该函数返回线性系统 AX=B 的解
torch.inverse(input, out=None) → Tensor | 计算方阵 input 的逆.
torch.matmul(tensor1, tensor2, out=None) | Matrix product of two tensors
torch.mm(mat1, mat2, out=None) → Tensor | 执行 mat1 和 mat2 的矩阵乘法.
torch.mv(mat, vec, out=None) → Tensor | 执行矩阵 mat 与向量 vec 的乘法操作.
torch.potrf(a, out=None) | 计算半正定矩阵 a: 的 Cholesky 分解
torch.potri(u, out=None) | 给定一个半正定矩阵的 Cholesky 分解因子 u, 计算该半正定矩阵的逆.
torch.potrs(b, u, out=None) | Solves a linear system of equations with a positive semidefinite matrix to be inverted given its given a Cholesky factor matrix u
torch.pstrf(a, out=None) | Computes the pivoted Cholesky decomposition of a positive semidefinite matrix a: returns matrices u and piv
torch.qr(input, out=None) -> (Tensor, Tensor) | 计算矩阵 input 的 QR 分解. 返回矩阵 q 和 r 使得 x=q∗rx=q∗r, 且 q 是一个 正交矩阵, r 是一个上三角矩阵
torch.svd(input, some=True, out=None) -> (Tensor, Tensor, Tensor) | U, S, V =torch.svd(A) 返回大小为 (n x m) 的实矩阵 A 的奇异值分解, 使得A=USV′∗
torch.symeig(input, eigenvectors=False, upper=True, out=None) -> (Tensor, Tensor) | e, V = torch.symeig(input) 返回实对称矩阵 input 的特征值和特征向量.